In [1]:
%matplotlib notebook 
import numpy as np
import matplotlib.pyplot as plt
from pandas.plotting import scatter_matrix
import pandas as pd
import visualization_metrics as v
import seaborn as sns
RP = v.RegrParams

params = {
    'plot': True,
    'undersample':  not True,
    'oversample': False 
}
suffix_file = "_averages"
dict_vals = {}
dict_vals_new = {}
In [2]:
#val = v.main("gen_averages.csv", plot=plot)
#dict_vals['rnd'] = val
In [3]:
rp = RP()
rp.is_overhead_node_linear = False
rp.is_latency_overhead_vertical = True
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/rr_20_nodes_4_depth_all_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['rr'] = val
dict_vals_new['rr'] = val_new

Int64Index([18, 2, 8, 10, 11, 16, 9, 7, 6, 5, 13, 12, 17, 19, 4, 3, 14, 15], dtype='int64')

Int64Index([26, 2, 11, 14, 15, 23, 12, 9, 8, 6, 18, 17, 24, 27, 5, 3, 20, 21], dtype='int64')

Int64Index([1], dtype='int64')

latency = 1.403402 * nb_nodes + 0.000000
err: []

overhead = -0.000000 * nb_nodes + 1.000000
err: [1.70769567e-31]

overhead = 0.000000 * latency + 1.000000
err: 0.0
1 = 0.000000 / nb_nodes + 0.000000 * latency + 1.000000 * overhead
(8.191362192111169e-15, 1.3877787807814457e-17, 1.0000000000000004)
err: [1.54480897e-27]
(1.8195391809767397e-15, -5.551115123125783e-17, 1.0000000000000009)
err2: [1.58544593e-27]
In [4]:
rp = RP()
rp.is_overhead_node_linear = False
rp.is_latency_overhead_vertical = True
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/double_rr_20_nodes_4_depth_all_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['double_rr'] = val
dict_vals_new['double_rr'] = val_new

Int64Index([4, 12, 9, 15, 17, 19, 5, 6, 3, 13, 11, 7, 10, 18, 16, 8, 2, 14], dtype='int64')

Int64Index([3, 9, 12, 6, 2, 11, 14, 4, 8, 13, 7, 5, 10], dtype='int64')

Int64Index([2, 4], dtype='int64')

latency = 0.721750 * nb_nodes + 0.000000
err: []

overhead = -0.053664 * nb_nodes + 2.785690
err: [5.71585827]

overhead = -0.081158 * latency + 2.856413
err: -0.47242341384855896
1 = 1.435098 / nb_nodes + 0.055589 * latency + 0.162048 * overhead
(1.4350980078581461, 0.05558876084261638, 0.16204777984468768)
err: [5.53736336]
(0.11909308040094774, 0.036185425185665365, 0.6012986563849584)
err2: [1.45949807]
In [5]:
rp = RP()
rp.is_overhead_node_linear = False
rp.is_latency_overhead_vertical = True
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/triple_rr_20_nodes_4_depth_all_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['triple_rr'] = val
dict_vals_new['triple_rr'] = val_new

Int64Index([2, 8, 16, 7, 10, 19, 13, 5, 3, 12, 15, 11, 4, 14, 18, 17, 6, 9], dtype='int64')

Int64Index([6, 3, 5, 2, 8, 9, 7, 4], dtype='int64')

Int64Index([3, 6, 1], dtype='int64')

latency = 0.496152 * nb_nodes + 0.000000
err: []

overhead = 0.004128 * nb_nodes + 3.178879
err: [21.10285518]

overhead = 0.051724 * latency + 3.105016
err: 0.08690592390279755
1 = 1.686019 / nb_nodes + 0.083985 * latency + 0.090728 * overhead
(1.6860191519808532, 0.08398478069454152, 0.09072798927157436)
err: [6.87316548]
(0.4048674665564243, 0.08250874411097947, 0.4014266527787466)
err2: [2.26140276]
In [6]:
rp = RP()
rp.is_latency_node_linear = False
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/overhead_10-20_nodes_4_depth_all_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['overhead'] = val
dict_vals_new['overhead'] = val_new

Int64Index([2, 3, 8, 7, 6, 9, 4, 5, 17, 16, 14, 13, 19, 18, 11, 15, 10], dtype='int64')

Int64Index([2], dtype='int64')

Int64Index([2, 3, 8, 7, 6, 9, 4, 5, 17, 16, 14, 13, 19, 18, 11, 15, 10], dtype='int64')

/home/ymaktepi/.local/share/virtualenvs/visualization-Ni0hAuWF/lib/python3.7/site-packages/matplotlib/pyplot.py:514: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).
  max_open_warning, RuntimeWarning)

latency = -0.000000 * nb_nodes + 2.000000
err: [6.95758177e-32]

overhead = 1.000000 * nb_nodes + 0.000000
err: []

latency = -0.000000 * overhead + 2.000000
err: [6.95758177e-32]
1 = 0.000000 / nb_nodes + 0.500000 * latency + -0.000000 * overhead
(1.4872200575614052e-14, 0.5000000000000002, -5.551115123125783e-17)
err: [1.69161436e-26]
(6.345629668569573e-15, 0.987729767831156, 0.0)
err2: [1.02457024e-26]
In [7]:
rp = RP()
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/arbitrary_20_nodes_4_depth_all_receivers_gen"+suffix_file+".csv", **params)
dict_vals['arbitrary'] = val
dict_vals_new['arbitrary'] = val_new

Int64Index([12, 2, 14, 6, 7, 18, 8, 13, 9, 17, 19, 10, 15, 5, 3, 16, 11, 4], dtype='int64')

Int64Index([33, 25, 24, 13, 14,  2,  5,  6, 30,  8, 27, 10, 34, 15, 17, 16,  3,
            20, 19, 31, 29, 28,  7, 23, 32, 39, 12,  9,  4, 22, 18, 11, 26, 35,
            21, 36, 40, 37, 38, 41, 48, 43, 44, 45, 47, 42, 50, 46, 51, 52],
           dtype='int64')

Int64Index([ 1,  2,  3,  4,  6,  5,  7,  8, 17, 28, 36,  9, 11, 12, 10, 23, 30,
            27, 37, 33, 22, 15, 16, 18, 19, 21, 25, 31, 20, 26, 32, 14, 13, 42,
            40, 24, 47, 43, 41, 38, 39, 35, 34, 45, 29, 48, 51, 50, 55],
           dtype='int64')

latency = 2.125410 * nb_nodes + 0.000000
err: []

overhead = 1.364195 * nb_nodes + 0.000000
err: []

latency = 1.316214 * overhead + 0.000000
err: []
1 = 2.556325 / nb_nodes + 0.025645 * latency + 0.002446 * overhead
(2.5563246430404476, 0.02564477491571528, 0.002446072549538837)
err: [29.24025267]
(0.861515329981979, 0.035444068265105426, 0.10625656632727554)
err2: [23.72254653]
In [8]:
rp = RP()
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/rr_20_nodes_4_depth_some_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['rr_some'] = val
dict_vals_new['rr_some'] = val_new

Int64Index([9, 19, 17, 10, 13, 11, 6, 2, 14, 4, 12, 18, 8, 16, 7, 5, 3, 15], dtype='int64')

Int64Index([10, 6, 9, 8, 7, 11, 13, 15, 12, 14, 4, 5, 2, 16, 3, 17, 18, 29], dtype='int64')

Int64Index([ 5,  6,  3,  4,  7, 11,  8,  9, 13, 10, 12,  2, 16,  1, 14, 20, 23,
            15, 17, 18, 19, 24, 21, 22],
           dtype='int64')

latency = 0.821168 * nb_nodes + 0.000000
err: []

overhead = 0.776206 * nb_nodes + 0.000000
err: []

latency = 0.869035 * overhead + 0.000000
err: []
1 = 1.812093 / nb_nodes + 0.059421 * latency + 0.015500 * overhead
(1.8120930652919365, 0.05942112232042412, 0.015499635327232617)
err: [13.38698133]
(0.47841781461106736, 0.03915142992250051, 0.2842386698202849)
err2: [6.64360666]
In [9]:
rp = RP()
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/double_rr_20_nodes_4_depth_some_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['double_rr_some'] = val
dict_vals_new['double_rr_some'] = val_new

Int64Index([18, 9, 17, 2, 10, 12, 19, 14, 3, 15, 13, 16, 7, 4, 11, 6, 5, 8], dtype='int64')

Int64Index([10, 11, 8, 9, 7, 6, 12, 5, 4, 13, 2, 3, 14, 15, 16, 21, 17, 35], dtype='int64')

Int64Index([ 4,  6,  8,  5,  7,  9,  3, 10, 11, 12, 13,  2, 14, 15,  1, 18, 19,
            16, 17, 20, 21, 22, 24, 31, 25, 23, 26, 32, 27, 28, 29, 30],
           dtype='int64')

latency = 0.772007 * nb_nodes + 0.000000
err: []

overhead = 0.882797 * nb_nodes + 0.000000
err: []

latency = 0.643053 * overhead + 0.000000
err: []
1 = 1.735095 / nb_nodes + 0.069139 * latency + 0.014010 * overhead
(1.7350953136421174, 0.06913949726269152, 0.014010069470366197)
err: [59.08920664]
(0.45896259498511444, 0.04577957826410295, 0.2808762624442059)
err2: [29.70269017]
In [10]:
rp = RP()
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/overhead_10-20_nodes_4_depth_some_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['overhead_some'] = val
dict_vals_new['overhead_some'] = val_new

Int64Index([3, 9, 11, 7, 17, 13, 16, 4, 12, 18, 6, 8, 19, 10, 14, 15, 2], dtype='int64')

Int64Index([5, 4, 6, 11, 7, 3, 2], dtype='int64')

Int64Index([11, 8, 15, 14, 9, 3, 5, 17, 6, 12, 7, 10, 4, 27, 22, 16, 18, 19,
            20, 1],
           dtype='int64')

latency = 0.378697 * nb_nodes + 0.000000
err: []

overhead = 1.064654 * nb_nodes + 0.000000
err: []

latency = 0.338291 * overhead + 0.000000
err: []
1 = 1.641392 / nb_nodes + 0.071877 * latency + 0.034428 * overhead
(1.6413920548536982, 0.07187695629412207, 0.03442799802951318)
err: [1.34023828]
(0.5257585987387473, 0.02924520747467041, 0.3010960381533629)
err2: [0.31311364]
In [11]:
rp = RP()
rp.is_overhead_node_linear = False
rp.is_latency_overhead_vertical = True
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/rr_20_nodes_4_depth_half_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['rr_half'] = val
dict_vals_new['rr_half'] = val_new

Int64Index([14, 13, 2, 16, 11, 9, 17, 12, 5, 3, 15, 18, 8, 19, 6, 4, 10, 7], dtype='int64')

Int64Index([6, 10, 4, 12, 7, 9, 5, 11, 14, 13, 15, 8, 2, 16, 3, 17, 18, 19,
            20],
           dtype='int64')

Int64Index([3, 2, 4, 5, 1, 6, 7, 8, 9, 10, 12, 11, 15, 14, 13], dtype='int64')

latency = 0.880346 * nb_nodes + 0.000000
err: []

overhead = 0.157861 * nb_nodes + 3.350669
err: [1251.17291985]

overhead = 0.116985 * latency + 3.899628
err: 0.1759700763433791
1 = 2.131255 / nb_nodes + 0.057053 * latency + 0.029978 * overhead
(2.131254691188073, 0.05705349007537232, 0.0299775494367789)
err: [21.50822112]
(0.5375773110310248, 0.05709765974506592, 0.30906832496943293)
err2: [12.49279238]
In [12]:
rp = RP()
rp.is_overhead_node_linear = False
rp.is_latency_overhead_vertical = True
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/double_rr_20_nodes_4_depth_half_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['double_rr_half'] = val
dict_vals_new['double_rr_half'] = val_new

Int64Index([19, 7, 4, 11, 13, 10, 5, 2, 8, 17, 18, 16, 3, 12, 15, 9, 6, 14], dtype='int64')

Int64Index([8, 5, 7, 4, 10, 6, 12, 11, 9, 2, 13, 3, 14, 15], dtype='int64')

Int64Index([4, 3, 5, 6, 2, 7, 1, 9, 8, 10, 16, 13, 12, 11, 15, 14], dtype='int64')

latency = 0.691791 * nb_nodes + 0.000000
err: []

overhead = 0.188915 * nb_nodes + 3.710140
err: [1191.45746795]

overhead = 0.193233 * latency + 4.318408
err: 0.19786932739205068
1 = 2.081783 / nb_nodes + 0.069942 * latency + 0.029098 * overhead
(2.08178338898302, 0.06994246538783573, 0.029098493670679532)
err: [9.89969464]
(0.5265869048327119, 0.06606599876404759, 0.301782065239413)
err2: [5.02276043]
In [13]:
rp = RP()
rp.is_overhead_node_linear = False
rp.is_latency_overhead_vertical = True
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/triple_rr_20_nodes_4_depth_half_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['triple_rr_half'] = val
dict_vals_new['triple_rr_half'] = val_new

Int64Index([12, 5, 10, 17, 16, 3, 18, 9, 4, 7, 2, 11, 14, 8, 15, 19, 6, 13], dtype='int64')

Int64Index([8, 9, 7, 5, 6, 4, 3, 10, 2, 11, 12], dtype='int64')

Int64Index([5, 4, 6, 7, 3, 8, 2, 10, 9, 1, 11, 12, 14, 16, 13, 15, 22], dtype='int64')

latency = 0.625886 * nb_nodes + 0.000000
err: []

overhead = 0.132137 * nb_nodes + 5.386722
err: [1425.81980818]

overhead = 0.395889 * latency + 4.288747
err: 0.27492062663369343
1 = 1.894300 / nb_nodes + 0.086086 * latency + 0.023345 * overhead
(1.8943000866646873, 0.08608589938787274, 0.023344524865197697)
err: [7.66745915]
(0.48587982114093464, 0.07586689688690443, 0.29007388829391484)
err2: [3.77639922]
In [14]:
rp = RP()
rp.is_latency_node_linear = False
rp.is_latency_overhead_linear = False
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/overhead_20_nodes_4_depth_half_receivers_gen" + suffix_file + ".csv", **params)
dict_vals['overhead_half'] = val
dict_vals_new['overhead_half'] = val_new

Int64Index([16, 3, 10, 15, 4, 17, 7, 9, 2, 14, 8, 5, 13, 18, 6, 12, 11, 19], dtype='int64')

Int64Index([4, 3, 2, 5, 6, 10, 7], dtype='int64')

Int64Index([12,  7,  8,  6,  5, 14, 10,  9,  3,  4, 13, 11,  2, 15, 17, 18,  1,
            16, 19, 22, 24, 21, 26],
           dtype='int64')

latency = -0.028952 * nb_nodes + 4.179053
err: [77.91585161]

overhead = 0.992801 * nb_nodes + 0.000000
err: []

latency = 0.021183 * overhead + 3.678620
err: [86.32591169]
1 = 1.381727 / nb_nodes + 0.136745 * latency + 0.027054 * overhead
(1.3817268774534157, 0.13674541226846904, 0.027053658583517798)
err: [6.71549386]
(0.5041283246782512, 0.03526900950333717, 0.3206038645877688)
err2: [2.16959163]
In [15]:
rp = RP()
params['regr_params'] = rp
val, val_new = v.main("generated/aggregated/arbitrary_20_nodes_4_depth_half_receivers_gen"+suffix_file+".csv", **params)
dict_vals['arbitrary_half'] = val
dict_vals_new['arbitrary_half'] = val_new

Int64Index([4, 11, 13, 18, 12, 15, 19, 8, 2, 14, 17, 16, 7, 3, 6, 10, 9, 5], dtype='int64')

Int64Index([18, 20, 15,  6, 19, 12, 17,  8,  9, 13, 16, 11, 10,  5, 21, 14, 22,
             4,  3, 24,  2, 23, 25, 26, 29,  7, 27, 28, 32, 30, 31, 33],
           dtype='int64')

Int64Index([ 3,  4,  2,  5,  6,  7, 10,  8, 16, 11,  1,  9, 13, 15, 17, 12, 14,
            19, 21, 22, 20, 23, 24, 18, 26, 27, 28, 35, 48, 32, 38, 33, 29, 31,
            30, 36, 25, 43, 49, 34, 37, 39, 40, 41, 42],
           dtype='int64')

latency = 1.337017 * nb_nodes + 0.000000
err: []

overhead = 1.299129 * nb_nodes + 0.000000
err: []

latency = 0.794749 * overhead + 0.000000
err: []
1 = 2.388230 / nb_nodes + 0.038789 * latency + 0.003905 * overhead
(2.38823049654114, 0.038788898137077796, 0.003905112394184177)
err: [16.96707575]
(0.726773908469052, 0.03351713922518822, 0.18023191201102573)
err2: [10.60837765]
In [16]:
def plot(dict_vals, filename):
    keys = sorted([k for k in dict_vals.keys() if k != 'rnd'])
    r = np.arange(len(keys))
    offset = 0.2
    l = [dict_vals[k] for k in keys]
    x, y, z = zip(*l)
    import seaborn as sns
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.bar(r-offset, x,width=offset,color='b',align='center')
    ax.bar(r,        y,width=offset,color='g',align='center')
    ax.bar(r+offset, z,width=offset,color='r',align='center')
    ax.set_xlabel("Strategy")
    ax.set_ylabel("Score")
    ax.set_title("Strategies scores")
    ax.set_xticks(r)
    plt.xticks(rotation=45)
    ax.set_xticklabels(keys)
    ax.legend(["nb_nodes", "latency", "overhead"])
    fig.tight_layout()
    plt.show()
    save_path = "./generated/imgs/"
    plt.savefig(save_path + filename + ".png", dpi=600)
In [17]:
dict_vals = {k:v for (k, v) in dict_vals.items() if "some" not in k}
dict_vals_new = {k:v for (k, v) in dict_vals_new.items() if "some" not in k}
In [18]:
for k, (a, b, c) in dict_vals.items():
    print(k, a, b, c)
    #print(k, c)

plot(dict_vals, "final_plot_basic_model")

rr 8.191362192111169e-15 1.3877787807814457e-17 1.0000000000000004
double_rr 1.4350980078581461 0.05558876084261638 0.16204777984468768
triple_rr 1.6860191519808532 0.08398478069454152 0.09072798927157436
overhead 1.4872200575614052e-14 0.5000000000000002 -5.551115123125783e-17
arbitrary 2.5563246430404476 0.02564477491571528 0.002446072549538837
rr_half 2.131254691188073 0.05705349007537232 0.0299775494367789
double_rr_half 2.08178338898302 0.06994246538783573 0.029098493670679532
triple_rr_half 1.8943000866646873 0.08608589938787274 0.023344524865197697
overhead_half 1.3817268774534157 0.13674541226846904 0.027053658583517798
arbitrary_half 2.38823049654114 0.038788898137077796 0.003905112394184177
In [19]:
for k, (a, b, c) in dict_vals_new.items():
    print(k, a, b, c)
    #print(k, c)
plot(dict_vals_new, "final_plot_new_model")

rr 1.8195391809767397e-15 -5.551115123125783e-17 1.0000000000000009
double_rr 0.11909308040094774 0.036185425185665365 0.6012986563849584
triple_rr 0.4048674665564243 0.08250874411097947 0.4014266527787466
overhead 6.345629668569573e-15 0.987729767831156 0.0
arbitrary 0.861515329981979 0.035444068265105426 0.10625656632727554
rr_half 0.5375773110310248 0.05709765974506592 0.30906832496943293
double_rr_half 0.5265869048327119 0.06606599876404759 0.301782065239413
triple_rr_half 0.48587982114093464 0.07586689688690443 0.29007388829391484
overhead_half 0.5041283246782512 0.03526900950333717 0.3206038645877688
arbitrary_half 0.726773908469052 0.03351713922518822 0.18023191201102573
In [20]:
def norm(t, max_t):
    new_t = ()
    return tuple(item/m for item, m in zip(t, max_t))

l = [v for v in dict_vals.values()]
x, y, z = zip(*l)
x = max(x)
y = max(y)
z = max(z)
t = (x,y,z)
dict_vals_norm = {k: norm(v, t) for k, v in dict_vals.items()}
plot(dict_vals_norm, "final_plot_norm_model")
In [ ]: